import axios from 'axios';

// 创建一个不使用代理的axios实例
const sparkAxios = axios.create({
    proxy: false
});

const API_BASE_URL = import.meta.env.VITE_APP_API_BASE_URL || 'http://localhost:8000';

export default {
  /**
   * 发送请求到讯飞星火API
   * @param {Object} params 请求参数
   * @param {string} params.model - 必需，模型版本 ['lite', 'generalv3', 'pro-128k', 'generalv3.5', 'max-32k', '4.0Ultra']
   * @param {Array} params.messages - 必需，消息数组
   * @param {string} params.user - 可选，用户唯一标识
   * @param {number} params.temperature - 可选，核采样阈值 [0,2]，默认1.0
   * @param {number} params.top_p - 可选，概率阈值 (0,1]，默认1
   * @param {number} params.top_k - 可选，随机选择范围 [1,6]，默认4
   * @param {number} params.presence_penalty - 可选，重复词惩罚 [-2.0,2.0]，默认0
   * @param {number} params.frequency_penalty - 可选，频率惩罚 [-2.0,2.0]，默认0
   * @param {boolean} params.stream - 可选，是否流式返回，默认false
   * @param {number} params.max_tokens - 可选，回答最大长度，默认4096
   * @param {Object} params.response_format - 可选，指定输出格式
   * @param {Array} params.tools - 可选，工具参数
   * @param {string|Object} params.tool_choice - 可选，工具选择
   * @param {Object} headers - 可选，请求头
   */
  sendSparkRequest: async function({ 
    messages,  // 必需，消息数组
    model = 'generalv3.5',  // 必需，模型版本
    user = 'default_user',  // 可选，用户唯一标识
    temperature = 1.0,  // 可选，默认1.0，范围[0,2]
    top_p = 1,  // 可选，默认1，范围(0,1]
    top_k = 4,  // 可选，默认4，范围[1,6]
    presence_penalty = 0,  // 可选，默认0，范围[-2.0,2.0]
    frequency_penalty = 0,  // 可选，默认0，范围[-2.0,2.0]
    stream = false,  // 可选，默认false
    max_tokens = 4096,  // 可选，默认4096
    response_format = null,  // 可选，指定输出格式
    tools = [],  // 可选，工具参数
    tool_choice = 'auto',  // 可选，工具选择
    web_search = null,  // 可选，是否开启搜索功能
    headers = {}  // 可选，请求头
  }) {
    // 验证必需参数
    if (!messages || !Array.isArray(messages) || messages.length === 0) {
      throw new Error('消息数组不能为空');
    }

    // 验证消息格式
    const validRoles = ['user', 'assistant', 'system', 'tool'];
    const invalidMessage = messages.find(msg => 
      !msg.role || !validRoles.includes(msg.role) || !msg.content || typeof msg.content !== 'string'
    );
    if (invalidMessage) {
      throw new Error('消息格式不正确，每条消息必须包含role和content字段');
    }

    // 验证模型版本
    const validModels = ['lite', 'generalv3', 'pro-128k', 'generalv3.5', 'max-32k', '4.0Ultra'];
    if (!validModels.includes(model)) {
      throw new Error('无效的模型版本');
    }

    // 验证参数范围
    if (temperature < 0 || temperature > 2) {
      throw new Error('temperature必须在[0,2]范围内');
    }

    if (top_p <= 0 || top_p > 1) {
      throw new Error('top_p必须在(0,1]范围内');
    }

    if (top_k < 1 || top_k > 6) {
      throw new Error('top_k必须在[1,6]范围内');
    }

    if (presence_penalty < -2.0 || presence_penalty > 2.0) {
      throw new Error('presence_penalty必须在[-2.0,2.0]范围内');
    }

    if (frequency_penalty < -2.0 || frequency_penalty > 2.0) {
      throw new Error('frequency_penalty必须在[-2.0,2.0]范围内');
    }

    // 验证max_tokens范围
    const isLargeModel = ['pro-128k', 'max-32k', '4.0Ultra'].includes(model);
    const maxTokensLimit = isLargeModel ? 8192 : 4096;
    if (max_tokens < 1 || max_tokens > maxTokensLimit) {
      throw new Error(`max_tokens必须在[1,${maxTokensLimit}]范围内`);
    }

    // 构建请求体
    const requestBody = {
      model,
      messages,
      user,
      temperature,
      top_p,
      top_k,
      presence_penalty,
      frequency_penalty,
      stream,
      max_tokens
    };

    // 添加可选参数
    if (response_format) requestBody.response_format = response_format;
    if (tools.length > 0) requestBody.tools = tools;
    if (tool_choice !== 'auto') requestBody.tool_choice = tool_choice;
    if (web_search !== null) {
      requestBody.tools = [
        ...(requestBody.tools || []),
        {
          type: "web_search",
          web_search: {
            enable: web_search
          }
        }
      ];
    }
    const API_SECRET = import.meta.env.VITE_APP_API_SECRET;  //VITE_API_SECRET

  console.log('requestBody:', requestBody);
    try {
      const response = await sparkAxios.post(`${API_BASE_URL}/api/chat/spark`, requestBody, {
        headers: {
          'Content-Type': 'application/json',
          'X-API-Secret': API_SECRET
        }
      });
      return response.data;
    } catch (error) {
      console.error('讯飞星火API请求失败:', error.response ? error.response.data : error.message);
      throw  error.response ? error.response.data : error.message|| error;
    }
  }
};